// 模块化
(function (){
    // Promise构造函数
    function Promise(excutor){
        console.log( 'Promise构造函数...' );

        // this -> Promise的实例对象
        this.state = 'pending';// 默认的状态
        this.result = undefined;// 默认的结果
        var _this = this;// 缓存this指向
        this.callbacks = [];// 缓存成功和失败的回调函数
        // [
        //     {// item
        //         'fnResolve': function (){},
        //         'fnReject': function (){}
        //     },
        //     {// item
        //         'fnResolve': function (){},
        //         'fnReject': function (){}
        //     },
        //     ...
        // ]

        // resolve函数
        function resolve(resolveVal){
            console.log( 'resolve函数...' );
            // 判断Promise对象的状态
            if (_this.state !== 'pending') {
                // Promise对象已经被修改过了
                return;// 结束执行函数
            }
            // 将Promise对象的状态改变为成功
            _this.state = 'fulfilled';
            // 修改Promise对象的结果
            _this.result = resolveVal;
            // 判断是否有缓存的回调函数
            if (_this.callbacks.length > 0) {
                // 遍历取出所有的成功回调函数并异步执行
                _this.callbacks.forEach(function (item){
                    setTimeout(function (){
                        item.fnResolve(_this.result);
                    })
                })
            }
        }

        // reject函数
        function reject(rejectVal){
            console.log( 'reject函数...' );
            // 判断Promise对象的状态
            if (_this.state !== 'pending') {
                // Promise对象已经被修改过了
                return;// 结束执行函数
            }
            // 将Promise对象的状态改变为失败
            _this.state = 'rejected';
            // 修改Promise对象的结果
            _this.result = rejectVal;
            // 判断是否有缓存的回调函数
            if (_this.callbacks.length > 0) {
                // 遍历取出所有的失败回调函数并异步执行
                _this.callbacks.forEach(function (item){
                    setTimeout(function (){
                        item.fnReject(_this.result);
                    })
                })
            }
        }

        // 调用执行器函数,同步执行
        // 执行器函数内部出现异常时,Promise对象的状态改变为失败
        try {
            excutor(resolve,reject);
        }catch(err){
            reject(err);
        }
    }

    // then方法: 指定Promise对象成功和失败的回调函数,返回一个新的Promise对象
    Promise.prototype.then = function (fnResolve,fnReject){
        // fnResolve 成功的回调函数
        // fnReject 失败的回调函数
        console.log( 'then方法...' );

        // this -> Promise实例对象
        var _this = this;// 缓存this指向
        
        // 判断Promise对象的状态
        if (this.state === 'fulfilled') {
            // fnResolve异步执行
            setTimeout(function (){
                fnResolve(_this.result);
            });
        }
        if (this.state === 'rejected') {
            // fnReject异步执行
            setTimeout(function (){
                fnReject(_this.result);
            });
        }
        if (this.state === 'pending') {
            // 缓存成功和失败的回调函数
            this.callbacks.push({
                'fnResolve': fnResolve,
                'fnReject': fnReject
            });
        }
    }

    // catch方法
    Promise.prototype.catch = function (){
        
    }

    // resolve静态方法
    Promise.resolve = function (){

    }

    // reject静态方法
    Promise.reject = function (){
        
    }

    // 对外暴露Promise函数(覆盖原来的Promise函数)
    window.Promise = Promise;
})();
